Ce cours vise à vous fournir les compétences nécessaires pour créer
des visualisations de données percutantes et informatives en utilisant
la bibliothèque ggplot2 de R. Que vous soyez un analyste de
données, un scientifique de données, ou simplement quelqu’un d’intéressé
par la data science, ce cours vous aidera à transformer vos données en
insights visuels compréhensibles.
La visualisation de données est essentielle dans le monde d’aujourd’hui.
ggplot2?ggplot2: Un Outil Puissant pour la Visualisation
de Données
ggplot2 est
une bibliothèque R largement utilisée pour la création de visualisations
de données de haute qualité.ggplot2 utilise les concepts de la “grammaire de la
graphique”, une approche systématique pour construire des graphiques en
couches.À la fin de ce cours, vous serez capable de :
ggplot2 pour créer une variété de
graphiques.Contenu du Cours : - Démonstrations - Exercices
Chaque graphique utilise ggplot()pour initialiser
l’objet ggplot et spécifie la source de données (data) et l’aesthetic
mapping (aes) qui définit quelles variables sont utilisées sur les axes
x et y, ainsi que d’autres paramètres esthétiques tels que la couleur,
la taille, etc.
library(tidyverse)
## -- Attaching core tidyverse packages ------------------------ tidyverse 2.0.0 --
## v dplyr 1.1.4 v readr 2.1.4
## v forcats 1.0.0 v stringr 1.5.1
## v ggplot2 3.4.4 v tibble 3.2.1
## v lubridate 1.9.3 v tidyr 1.3.0
## v purrr 1.0.2
## -- Conflicts ------------------------------------------ tidyverse_conflicts() --
## x dplyr::filter() masks stats::filter()
## x dplyr::lag() masks stats::lag()
## i Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors
head(diamonds)
## # A tibble: 6 x 10
## carat cut color clarity depth table price x y z
## <dbl> <ord> <ord> <ord> <dbl> <dbl> <int> <dbl> <dbl> <dbl>
## 1 0.23 Ideal E SI2 61.5 55 326 3.95 3.98 2.43
## 2 0.21 Premium E SI1 59.8 61 326 3.89 3.84 2.31
## 3 0.23 Good E VS1 56.9 65 327 4.05 4.07 2.31
## 4 0.29 Premium I VS2 62.4 58 334 4.2 4.23 2.63
## 5 0.31 Good J SI2 63.3 58 335 4.34 4.35 2.75
## 6 0.24 Very Good J VVS2 62.8 57 336 3.94 3.96 2.48
ggplot(data = diamonds, aes(x = cut)) +
geom_bar()
ggplot(data = diamonds, aes(x = carat)) +
geom_histogram(binwidth = 0.1)
ggplot(data = diamonds, aes(x = carat, y = price)) +
geom_point()
ggplot(data = diamonds, aes(x = carat, y = price)) +
geom_jitter()
data <- data.frame(
Group = rep(c("A", "B", "C"), each = 100),
Value = rnorm(300)
)
# Créez un boxplot en utilisant ggplot2
ggplot(data, aes(x = Group, y = Value)) +
geom_boxplot()
diamonds %>%
group_by(carat) %>%
summarise(mean_price = mean(price)) %>%
ggplot(aes(x = carat, y = mean_price)) +
geom_line()
ggplot2 est un système de création de graphiques pour R,
basé sur la grammaire des graphiques. Il permet de créer des graphiques
complexes en assemblant des éléments de base de manière intuitive.
# Barplot des Diamants par Qualité de Coupe
?scale_fill_brewer()
## starting httpd help server ... done
ggplot(data = diamonds, aes(x = cut, fill = cut)) +
geom_bar() +
labs(title = "Distribution des Diamants par Qualité de Coupe",
x = "Qualité de la Coupe",
y = "Nombre de Diamants") +
scale_fill_brewer(palette = "Set1", guide = 'none') +
theme_minimal()
ggplot(data = diamonds, aes(x = cut, fill = cut)):
Initialise un graphique avec les données diamonds, avec
cut comme axe x et couleur.geom_bar(): Ajoute des barres au graphique.labs(): Définit le titre et les étiquettes des
axes.scale_fill_brewer(): Personnalise les couleurs des
barres.theme_minimal(): Utilise un thème minimaliste pour le
graphique.ggplot(data = diamonds, aes(x = carat, y = price, color = clarity)) +
geom_point() +
labs(title = "Relation entre le Poids et le Prix des Diamants",
x = "Carats",
y = "Prix (USD)",
color = "Clarté") +
scale_color_brewer(type = "seq", palette = "Blues") +
theme_classic() +
theme(
axis.title = element_text(colour = "blue", face = "bold"),
plot.title = element_text(colour = "blue", face = "bold"),
plot.subtitle = element_text(colour = "blue", face = "bold"))
clarity) pour colorer les
points.scale_color_brewer(): Applique une palette de
couleurs.theme_classic(): Utilise un thème classique.theme(): Personnalise davantage les éléments du
graphique.# Utilisation de `theme_set`
theme_set(theme_bw() + theme(
axis.title = element_text(colour = "blue", face = "bold"),
plot.title = element_text(colour = "blue", face = "bold"),
plot.subtitle = element_text(colour = "blue", face = "bold")))
# Différence entre Setting et Mapping
# gauche : setting
ggplot(mpg, aes(x = displ, y = hwy)) +
geom_point(shape = 10)
# droite : mapping
ggplot(mpg, aes(x = displ, y = hwy, shape = drv)) +
geom_point()
setting) et mapper une propriété à une variable
(mapping).# Plusieurs façons de modifier les couleurs et les thèmes
p <- ggplot(mpg, aes(x = displ, y = hwy)) +
geom_point()
p <- p + geom_point(color = "red")
p <- p + aes(color = drv)
p <- p + aes(color = cty > 20)
p + theme_bw()
p + xlim(0, 8) + ylim(0, 40)
## Warning: Removed 3 rows containing missing values (`geom_point()`).
## Removed 3 rows containing missing values (`geom_point()`).
p
theme_bw(),
xlim(), ylim(),
scale_x_continuous(), et scale_y_continuous()
pour personnaliser le graphique.ggplot(mpg, aes(x = displ, y = hwy)) +
geom_point() +
scale_x_continuous(breaks = seq(0, 10, 1)) +
scale_y_continuous(labels = scales::comma_format(scale = 1e-4)) +
theme(axis.text.x = element_text(size = 10, color = "blue"),
axis.text.y = element_text(size = 12, color = "green"))
babynamesbabynames, et viridis utilisées pour les
données, et les palettes de couleurs, respectivement.babynames et filtrage par
sexe.ggplot() initialise le graphique.geom_area() crée des graphiques à aire.scale_fill_viridis() applique une palette de
couleurs.theme() et theme_ipsum() sont utilisés
pour personnaliser l’apparence du graphique.facet_wrap(~name, scale="free_y") divise le graphique
en plusieurs panneaux, un pour chaque nom, avec des échelles y
libres.Ce script crée un graphique qui montre la popularité de certains prénoms américains au fil du temps.
library(babynames)
library(viridis)
## Loading required package: viridisLite
# Load dataset from github
data <- read.table("https://raw.githubusercontent.com/holtzy/data_to_viz/master/Example_dataset/3_TwoNumOrdered.csv", header=T)
data$date <- as.Date(data$date)
# Load dataset from github
don <- babynames %>%
filter(name %in% c("Ashley", "Amanda", "Mary", "Deborah",
"Dorothy", "Betty", "Helen", "Jennifer", "Shirley")) %>%
filter(sex=="F")
# Plot
don %>%
ggplot( aes(x=year, y=n, group=name, fill=name)) +
geom_area() +
scale_fill_viridis(discrete = TRUE) +
theme(legend.position="none") +
ggtitle("Popularity of American names in the previous 30 years") +
theme(
legend.position="none",
panel.spacing = unit(0, "lines"),
strip.text.x = element_text(size = 8),
plot.title = element_text(size=13)
) +
facet_wrap(~name, scale="free_y")
date est
convertie au format Date.ggplot() initialise le graphique.geom_line() et geom_point() sont utilisés
pour créer un graphique linéaire avec des points mis en évidence.theme_ipsum() avec base_family = "Arial"
applique un thème avec une police standard.ggtitle() ajoute un titre au graphique.Ce script montre l’évolution récente du prix du bitcoin.
data <- read.table("https://raw.githubusercontent.com/holtzy/data_to_viz/master/Example_dataset/3_TwoNumOrdered.csv", header=T)
data$date <- as.Date(data$date)
# Plot
data %>%
tail(1000) %>%
ggplot( aes(x=date, y=value)) +
geom_line( color="grey") +
geom_point(shape=21, color="black", fill="#69b3a2", size=6) +
ggtitle("Evolution of bitcoin price")
leafletLeaflet est une bibliothèque JavaScript open source très populaire,
utilisée pour créer des cartes interactives sur le Web. Bien qu’elle
soit principalement basée sur JavaScript, elle peut être utilisée dans
le langage de programmation R grâce à un package appelé
leaflet pour R. Voici quelques points clés à connaître sur
Leaflet dans le contexte de R :
Création de cartes interactives: Leaflet vous permet de créer des cartes interactives que vous pouvez intégrer dans des applications web ou des documents R Markdown. Ces cartes peuvent être personnalisées avec différents styles et fonctionnalités.
Facilité d’utilisation: Même pour les débutants, Leaflet est relativement simple à utiliser en R. Vous pouvez commencer avec quelques lignes de code pour générer une carte de base, puis progressivement ajouter des fonctionnalités plus complexes.
Superpositions et marqueurs: Vous pouvez ajouter des superpositions à vos cartes, comme des marqueurs, des cercles ou des polygones, pour représenter des données géographiques. Ces éléments peuvent être interactifs, affichant des informations supplémentaires lorsque l’utilisateur clique dessus ou passe la souris dessus.
Intégration avec des données spatiales: Leaflet
pour R fonctionne bien avec des données spatiales. Vous pouvez utiliser
des packages comme sf (simple features) pour manipuler des
données géographiques, puis les visualiser avec Leaflet.
Personnalisation: Vous avez la possibilité de personnaliser l’apparence de votre carte avec différents styles de tuiles (par exemple, OpenStreetMap, Mapbox) et d’ajouter des fonctionnalités comme des couches de contrôle, des légendes, et plus encore.
Pour commencer avec Leaflet en R, vous devez d’abord installer et
charger le package leaflet. Ensuite, vous pouvez utiliser
des fonctions comme leaflet() pour créer une carte et
addTiles() pour ajouter des tuiles de fond. De là, vous
pouvez explorer d’autres fonctions pour ajouter des marqueurs, des
couches, etc.
Voici un exemple de code simple pour créer une carte de base avec Leaflet en R :
library(leaflet)
# Créer une carte de base
leaflet() %>% addTiles()
Voici un exemple de script pour génèrer une carte interactive sur laquelle vous pouvez zoomer et vous déplacer
if (!require(leaflet)) {
install.packages("leaflet")
}
## Loading required package: leaflet
library(leaflet)
Cette partie vérifie d’abord si le package leaflet est
installé (require(leaflet)). Si ce n’est pas le cas
(!require(leaflet)), il l’installe
(install.packages("leaflet")). Ensuite, le package
leaflet est chargé en mémoire avec
library(leaflet), ce qui permet d’utiliser ses
fonctions.
map <- leaflet() %>%
addTiles() # Ajoute les tuiles de base d'OpenStreetMap
Ici, une carte de base est créée avec leaflet() et des
tuiles par défaut (généralement d’OpenStreetMap) sont ajoutées avec
addTiles(). Le résultat est stocké dans la variable
map.
map <- map %>%
addMarkers(lng = -0.09, lat = 51.50, popup = "The marker is placed at London")
Cette ligne ajoute un marqueur sur la carte. Le marqueur est placé à Londres (longitude -0.09, latitude 51.50), et un texte popup s’affiche lorsque vous cliquez sur le marqueur (“The marker is placed at London”).
map <- map %>%
addProviderTiles(providers$Stamen.TonerLite)
Ici, le style de la carte est changé en utilisant une tuile
différente fournie par Stamen.TonerLite, donnant à la carte
un aspect visuel différent.
Données pour les marqueurs supplémentaires :
data <- data.frame(
lng = c(-0.09, -0.11, -0.12),
lat = c(51.50, 51.52, 51.48),
label = c("Point 1", "Point 2", "Point 3")
)
Cette partie crée un data.frame contenant des
coordonnées et des étiquettes pour trois points
supplémentaires.
Ajouter des marqueurs supplémentaires :
map <- map %>%
addMarkers(data = data, ~lng, ~lat, popup = ~label)
Ces lignes ajoutent des marqueurs supplémentaires à la carte en
utilisant les données du data.frame créé précédemment.
Chaque marqueur affiche le texte correspondant dans label
lorsqu’on clique dessus.
map
Enfin, cette ligne affiche la carte créée, avec tous les marqueurs et modifications apportées.
VOici le code en intégralité :
# Installer et charger le package leaflet
if (!require(leaflet)) {
install.packages("leaflet")
}
library(leaflet)
# Créer une carte de base
map <- leaflet() %>%
addTiles() # Ajoute les tuiles de base d'OpenStreetMap
# Ajouter un marqueur
map <- map %>%
addMarkers(lng = -0.09, lat = 51.50, popup = "The marker is placed at London")
# Changer le fond de carte
map <- map %>%
addProviderTiles(providers$Stamen.TonerLite)
# Données pour les marqueurs supplémentaires
data <- data.frame(
lng = c(-0.09, -0.11, -0.12),
lat = c(51.50, 51.52, 51.48),
label = c("Point 1", "Point 2", "Point 3")
)
# Ajouter des marqueurs supplémentaires
map <- map %>%
addMarkers(data = data, ~lng, ~lat, popup = ~label)
# Afficher la carte
map
Définition des Coordonnées de Paris :
Paris <- c(2.351462,48.8567)
Cette ligne crée un vecteur nommé Paris avec la
longitude et la latitude de Paris, France.
Création et Configuration de la Carte :
m2 <- leaflet() %>% setView(lng = Paris[1], lat = Paris[2], zoom = 12) %>%
addTiles()
Ici, une carte est créée avec leaflet() et la vue est
centrée sur Paris avec un niveau de zoom de 12. Les tuiles de base
(généralement d’OpenStreetMap) sont ajoutées avec
addTiles().
Modification du Style de la Carte :
m2 %>% addProviderTiles("Stamen.Toner")
Cette ligne change le style de la carte en utilisant la tuile
Stamen.Toner, qui offre un design graphique
distinct.
content <- paste(sep = "<br/>",
"<b><a href='https://www.intelligence-artificielle-school.com/ecole/nos-campus/toulouse/'>IA School - Toulouse</a></b>",
"2 Bd de Strasbourg",
"31000 Toulouse"
)
leaflet() %>%
addTiles() %>%
addPopups(1.4485130539619018, 43.60676750775245,
content, options = popupOptions(closeButton = FALSE)
)
Création du Contenu du Popup :
content <- paste(sep = "<br/>", ...)
Cette portion crée une chaîne HTML content qui sera
utilisée dans le popup. Elle contient un lien vers le site web de l’IA
School à Toulouse, ainsi que l’adresse de l’école, formatée avec des
balises HTML pour une meilleure présentation.
Création et Configuration de la Carte avec Popup :
leaflet() %>%
addTiles() %>%
addPopups(...)
Une nouvelle carte est créée, des tuiles de base sont ajoutées, et un
popup est placé aux coordonnées spécifiées (Toulouse, France). Le popup
affiche le contenu HTML défini précédemment. L’option
closeButton = FALSE signifie que le popup n’aura pas de
bouton de fermeture.
Dans les deux cas, ces blocs de code illustrent comment créer des
cartes interactives en R avec le package leaflet, en se
concentrant sur des emplacements spécifiques (Paris et Toulouse) et en
utilisant des fonctionnalités telles que les vues personnalisées, les
styles de tuiles et les popups.
plotlyLe package Plotly permet de créer des graphiques web interactifs de qualité publication.
La première chose à faire est d’installer et de charger le package Plotly avec :
# install.packages("plotly")
library(plotly)
##
## Attaching package: 'plotly'
## The following object is masked from 'package:ggplot2':
##
## last_plot
## The following object is masked from 'package:stats':
##
## filter
## The following object is masked from 'package:graphics':
##
## layout
De plus, nous avons besoin de données pour travailler. Nous allons créer x, y et y3 avec des valeurs numériques pour les utiliser plus tard dans nos exemples.
x = c(1, 2, 3, 4, 5)
y = c(6, 7, 8, 9, 10)
y3 = c(-6, -7, -8, -9, -10)
La première chose à faire est d’appeler plot_ly(). Le
premier argument est les données que nous voulons tracer (x & y), le
second décrit le type de graphique, tandis que le troisième définit
comment nos données seront affichées dans le graphique. Ici, nous
voulons un graphique en ligne, donc nous choisissons “lines”. Regardez
l’exemple ci-dessous.
plot_ly(
x = c(1, 2, 3),
y = c(4, 5, 6),
type = "scatter",
mode = "lines"
)
La première chose à faire est d’appeler plot_ly(). Ici,
nous voulons un nuage de points, donc nous choisissons “markers”, qui
est le choix par défaut, donc il peut être omis. Regardez l’exemple
ci-dessous.
plot_ly(
x = c(1, 2, 3),
y = c(4, 5, 6),
type = "scatter",
mode = "markers"
)
La première chose à faire est d’appeler plot_ly(). Le
premier argument est les données que nous voulons tracer (x & y), le
second décrit le type de graphique, qui est maintenant un diagramme à
barres.
plot_ly(
x = c(1, 2, 3),
y = c(4, 5, 6),
type = "bar"
)
La première chose à faire est d’appeler plot_ly(). Ici,
nous voulons un graphique à bulles, donc nous choisissons “markers”.
Ensuite, nous définissons la taille pour chaque point et enfin sa
couleur. Regardez l’exemple ci-dessous.
plot_ly(
x = c(1, 2, 3),
y = c(4, 5, 6),
type = "scatter",
mode = "markers",
size = c(2, 6, 9),
marker = list(color = c("red", "black", "yellow"))
)
## Warning: `line.width` does not currently support multiple values.
La première chose à faire est d’appeler plot_ly(). Le
premier argument est les données que nous voulons tracer, qui est
l’ensemble de données “volcano” et sera donné comme une matrice
numérique “z”, le second décrit le type de graphique, qui est maintenant
une carte de chaleur. Regardez l’exemple ci-dessous.
plot_ly(
z = volcano,
type = "heatmap"
)
La première chose à faire est d’appeler plot_ly(). Ici,
nous voulons un graphique en aires, donc nous choisissons “lines” en
combinaison avec l’argument fill. Regardez l’exemple
ci-dessous.
plot_ly(
x = c(1, 2, 3),
y = c(4, 5, 6),
type = "scatter",
mode = "lines",
fill = "tozeroy"
)
Améliorons maintenant la mise en page de notre graphique. D’abord, nous verrons comment ajouter une trace à cela. Nous le faisons si nous voulons séparer nos marqueurs en groupes. Regardez l’exemple ci-dessous, dans lequel le premier groupe a y > 0 et l’autre y < 0 :
df <- data.frame(
x = c(1, 2, 3),
y = c(4, 5, 6),
y3 = c(-4, -5, -6)
)
df %>%
plot_ly(
type = "scatter",
mode = "markers"
) %>%
add_trace(x = ~x, y = ~y3)
Nous pouvons également ajouter la trace comme une légende dans notre graphique, définir sa position précise et la colorer. Regardez l’exemple ci-dessous :
df %>%
plot_ly(
type = "scatter",
mode = "markers"
) %>%
add_trace(x = ~x, y = ~y3) %>%
layout(
legend = list(
x = 1,
y = 1,
bgcolor = "yellow"
)
)
La dernière chose que nous devrions être capables de faire lors de la création d’un graphique est de gérer les axes. D’abord, nous créons une liste qui contient toutes les caractéristiques des axes, puis nous attachons cette liste aux deux axes comme l’exemple ci-dessous :
library(tidyverse)
library(plotly)
# Création du 1er facteur "magFactor" qui catégorise la magnitude des séismes
quakes$magFactor <- factor(floor(quakes$mag))
# Création du second facteur "region" qui catégorise la région géographique des séismes (Est/Ouest)
quakes$region <- factor(quakes$long >= 175, labels = c("Ouest", "Est"))
head(quakes, n = 5)
## lat long depth mag stations magFactor region
## 1 -20.42 181.62 562 4.8 41 4 Est
## 2 -20.62 181.03 650 4.2 15 4 Est
## 3 -26.00 184.10 42 5.4 43 5 Est
## 4 -17.97 181.66 626 4.1 19 4 Est
## 5 -20.42 181.96 649 4.0 11 4 Est
plot_ly(x = quakes$mag, type = "histogram") %>%
layout(title = "Magnitude des séismes")
axe_x <- list(
autotick = FALSE, # pour contrôler le pas de l'axe des abscisses
ticks = "outside", # ou "inside"
dtick = 20, # le nombre d'intervalles
ticklen = 10, # la longueur des indicateurs
tickwidth = 2, # la largeur des indicateurs
tickcolor = toRGB("blue"), # la couleur
zeroline = TRUE,
showline = TRUE,
zerolinecolor = toRGB("red"), # pour mettre en exergue la droite 'x = 0'
zerolinewidth = 3,
linecolor = toRGB("black"),
linewidth = 2
)
# axe_y <- list() # On pourrait faire de même avec l'axe des ordonnées
plot_ly(alpha = 0.8, histnorm = "probability", xlim = c()) %>%
add_histogram(x = quakes$long, name = "Longitudes") %>%
add_histogram(x = quakes$stations, name = "Nombre de stations") %>%
add_histogram(x = quakes$lat, name = "Latitudes") %>%
layout(title = "Distribution empirique de trois variables décrivant les séismes",
barmode = "overlay", xaxis = axe_x)
Voici un exemple de script d’analyse complet :
# Chargement des bibliothèques nécessaires
library(plotly)
library(tidyverse)
library(lubridate)
# Configurer la graine aléatoire pour la reproductibilité
set.seed(123)
# Créer une séquence de dates (chaque mois de 2020)
dates <- seq(ymd("2020-01-01"), ymd("2020-12-31"), by="month")
# Codes d'état des États-Unis (exemple avec 5 états)
state_codes <- c("AL", "AK", "AZ", "AR", "CA")
# Générer des données aléatoires
num_rows <- length(dates) * length(state_codes)
df <- data.frame(
time = rep(dates, each=length(state_codes)),
state_code = rep(state_codes, times=length(dates)),
num_colonies = sample(100:10000, num_rows, replace = TRUE),
percent_lost = runif(num_rows, 0, 100),
varroa_mites = runif(num_rows, 0, 100),
other_pests = runif(num_rows, 0, 100),
diseases = runif(num_rows, 0, 100),
pesticides = runif(num_rows, 0, 100),
other = runif(num_rows, 0, 100),
unknown = runif(num_rows, 0, 100)
)
# Afficher les premières lignes du dataframe
head(df)
## time state_code num_colonies percent_lost varroa_mites other_pests
## 1 2020-01-01 AL 2562 33.28235 35.39046 96.110479
## 2 2020-01-01 AK 2610 48.86130 64.99852 72.839443
## 3 2020-01-01 AZ 8817 95.44738 37.47140 68.637508
## 4 2020-01-01 AR 3085 48.29024 35.54454 5.284394
## 5 2020-01-01 CA 1941 89.03502 53.36879 39.522013
## 6 2020-02-01 AL 9433 91.44382 74.03344 47.784538
## diseases pesticides other unknown
## 1 13.710608 11.94048 13.70675 43.61300
## 2 39.658459 52.60297 90.53096 46.40166
## 3 22.498533 22.50734 57.63018 16.52981
## 4 5.795856 48.64118 39.54489 58.49366
## 5 39.589269 37.02148 44.98025 27.07780
## 6 6.492830 98.33502 70.65019 23.00969
fig <- df %>%
plot_ly() %>%
add_trace(
type = "choropleth",
locations = ~state_code,
locationmode = "USA-states",
z = ~varroa_mites,
colorscale = "Viridis_r",
color = ~varroa_mites
) %>%
layout(
geo = list(scope = "usa"),
frame = ~time
)
fig
## Warning: 'layout' objects don't have these attributes: 'frame'
## Valid attributes include:
## '_deprecated', 'activeshape', 'annotations', 'autosize', 'autotypenumbers', 'calendar', 'clickmode', 'coloraxis', 'colorscale', 'colorway', 'computed', 'datarevision', 'dragmode', 'editrevision', 'editType', 'font', 'geo', 'grid', 'height', 'hidesources', 'hoverdistance', 'hoverlabel', 'hovermode', 'images', 'legend', 'mapbox', 'margin', 'meta', 'metasrc', 'modebar', 'newshape', 'paper_bgcolor', 'plot_bgcolor', 'polar', 'scene', 'selectdirection', 'selectionrevision', 'separators', 'shapes', 'showlegend', 'sliders', 'smith', 'spikedistance', 'template', 'ternary', 'title', 'transition', 'uirevision', 'uniformtext', 'updatemenus', 'width', 'xaxis', 'yaxis', 'barmode', 'bargap', 'mapType'
Pour faire une figure contenant plusieurs graphiques dans la même fenêtre, on doit utiliser la fonction subplot. Les principaux paramètres de cette dernière sont:
…: Une série de graphiques plotly ou ggplot2 nrows: Le nombre de rangés sur lesquelles distribuer les graphiques shareX/shareY: Partager l’axe X / Y
# Graphique 1
gg_quakes <- qplot(long, lat, data = quakes, color = region) + coord_quickmap()
## Warning: `qplot()` was deprecated in ggplot2 3.4.0.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
gg_quakes
# Nous avons produit un graphique ggplot classique, non-interactif. Pour le rendre interactif, il suffit d’appliquer la fonction ggplotly ainsi:
p_scatter <- ggplotly(gg_quakes)
# Graphique 2
p_box <- plot_ly(data = quakes[quakes$region == "Est",],
x = ~ mag, type = "box", name = "Est") %>%
add_trace(data = quakes[quakes$region == "Ouest",], x = ~ mag, name = "Ouest")
# Multi-graphique :
subplot(p_scatter, p_box, nrows = 1, shareX = FALSE, shareY = FALSE, margin = 0.05) %>%
layout(title = "Longitude, latitude et magnitude des tremblements de terre",
xaxis = list(title = "Longitude"),
yaxis = list(title = "Latitude", scaleanchor = "x"),
xaxis2 = list(title = "Magnitude"))
## Warning: Can only have one: config
Pour en savoir plus : (data to viz)[https://www.data-to-viz.com/]
Pour commencer à pratiquer, suivez ces étapes :
Accédez au Dépôt GitHub : Visitez l’URL fournie : https://github.com/universdesdonnees/Introduction-a-R pour accéder au dépôt GitHub contenant les matériaux du cours.
Trouvez le Fichier des Exercices : Dans le dépôt, localisez le fichier nommé exercices6.txt. Ce fichier contient les premiers exercices que vous devez pratiquer.
Lisez et Essayez de Résoudre les Exercices : Ouvrez le fichier exercices6.txt et lisez attentivement les exercices. Essayez de les résoudre par vous-même dans votre environnement R (comme RStudio). Il est important de pratiquer par vous-même avant de regarder les solutions pour mieux apprendre.
Consultez la Correction : Une fois que vous avez tenté de résoudre les exercices, ou si vous rencontrez des difficultés, consultez le fichier correction_exercices6.R pour voir les solutions. Analysez les solutions pour comprendre les méthodes et logiques utilisées.